What kind of testing have you done with this so far?

Here's what I see as the path forward on this, in roughly this order:

1. debug symbols missing when running with valgrind #896 - send patch to valgrind team fixing the bug so that we don't need the --no-rosegment workaround.
2. Add language support for valgrind. Auto-enable it for some targets in debug/release-safe modes. It would automatically do the marking memory as undefined, when you assign undefined to it. std.mem.Allocator would then get this for free, without introducing one more barrier to comptime allocators.
3. The std.valgrind module is generally useful and would be a good candidate to live in the zig standard library. However language support for valgrind will probably emit inline assembly directly, without going through the trouble of a C ABI or parsing .zig code.
4. More experimentation/research can be done into more integrations with valgrind, potentially even as part of the zig language. (In the same way that it is useful to both zig and valgrind to know that you are setting something to undefined, it could be useful to both zig and valgrind to know that this memory has just been "allocated" or "freed", for example - see the noalias LLVM attribute on return values)

Windows has different inline assembly.

It didn't seem to when I looked, it just doesn't take that code path in msvc due to using GCC inline assembly?

I tried the code and it gave an invalid LLVM module error

That must be new, I ran+tested the code in this PR.

As @Sahnvour notes, you can't pass an array directly to inline assembly.

Will fix.

It's a bug in zig that it isn't a compile error.

Is there an issue open for that?

Is there an issue open for that?

There's #215 which is broader in scope. Actually from my experience and what @andrewrk told me about it, inline asm has enough support for basic stuff (namely doing syscalls) but that's about it. When you deviate a bit from simple uses, be sure to check with a debug build of Zig to trigger LLVM asserts.

One quick test you can do to show this is working is:

valgrindtest.zig:

const std = @import("std");
const valgrind = std.valgrind; // @import("./std/valgrind/index.zig");

pub fn main() void {
    std.debug.warn("{}\n", valgrind.runningOnValgrind());
}

$ zig build-exe valgrindtest.zig
$ ./valgrindtest 
0
$ valgrind ./valgrindtest 
==3338== Memcheck, a memory error detector
==3338== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3338== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==3338== Command: ./valgrindtest
==3338== 
1
==3338== 
==3338== HEAP SUMMARY:
==3338==     in use at exit: 0 bytes in 0 blocks
==3338==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
==3338== 
==3338== All heap blocks were freed -- no leaks are possible
==3338== 
==3338== For counts of detected and suppressed errors, rerun with: -v
==3338== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)